home *** CD-ROM | disk | FTP | other *** search
/ Languguage OS 2 / Languguage OS II Version 10-94 (Knowledge Media)(1994).ISO / language / embedded / m68k / 68343ffp.arc / FFPSIN.SA < prev    next >
Text File  |  1989-08-30  |  14KB  |  284 lines
  1.          TTL       FFP SINE COSINE TANGENT (FFPSIN/FFPCOS/FFPTAN/FFPSINCS)
  2. ***************************************
  3. * (C) COPYRIGHT 1981 BY MOTOROLA INC. *
  4. ***************************************
  5.  
  6. *************************************************
  7. *        FFPSIN FFPCOS FFPTAN FFPSINCS          *
  8. *     FAST FLOATING POINT SINE/COSINE/TANGENT   *
  9. *                                               *
  10. *  INPUT:   D7 - INPUT ARGUMENT (RADIAN)        *
  11. *                                               *
  12. *  OUTPUT:  D7 - FUNCTION RESULT                *
  13. *           (FFPSINCS ALSO RETURNS D6)          *
  14. *                                               *
  15. *     ALL OTHER REGISTERS TOTALLY TRANSPARENT   *
  16. *                                               *
  17. *  CODE SIZE: 334 BYTES   STACK WORK: 38 BYTES  *
  18. *                                               *
  19. *  CONDITION CODES:                             *
  20. *        Z - SET IF RESULT IN D7 IS ZERO        *
  21. *        N - SET IF RESULT IN D7 IS NEGATIVE    *
  22. *        C - UNDEFINED                          *
  23. *        V - SET IF RESULT IS MEANINGLESS       *
  24. *            (INPUT MAGNITUDE TOO LARGE)        *
  25. *        X - UNDEFINED                          *
  26. *                                               *
  27. *  FUNCTIONS:                                   *
  28. *             FFPSIN   -  SINE RESULT           *
  29. *             FFPCOS   -  COSINE RESULT         *
  30. *             FFPTAN   -  TANGENT RESULT        *
  31. *             FFPSINCS -  BOTH SINE AND COSINE  *
  32. *                         D6 - SIN, D7 - COSINE *
  33. *                                               *
  34. *  NOTES:                                       *
  35. *    1) INPUT VALUES ARE IN RADIANS.            *
  36. *    2) FUNCTION FFPSINCS RETURNS BOTH SINE     *
  37. *       AND COSINE TWICE AS FAST AS CALCULATING *
  38. *       THE TWO FUNCTIONS INDEPENDENTLY FOR     *
  39. *       THE SAME VALUE.  THIS IS HANDY FOR      *
  40. *       GRAPHICS PROCESSING.                    *
  41. *    2) INPUT ARGUMENTS LARGER THAN TWO PI      *
  42. *       SUFFER REDUCED PRECISION.  THE LARGER   *
  43. *       THE ARGUMENT, THE SMALLER THE PRECISION.*
  44. *       EXCESSIVELY LARGE ARGUMENTS WHICH HAVE  *
  45. *       LESS THAN 5 BITS OF PRECISION ARE       *
  46. *       RETURNED UNCHANGED WITH THE "V" BIT SET.*
  47. *    3) FOR TANGENT ANGLES OF INFINITE VALUE    *
  48. *       THE LARGEST POSSIBLE POSITIVE NUMBER    *
  49. *       IS RETURNED ($FFFFFF7F). THIS STILL     *
  50. *       GIVES RESULTS WELL WITHIN SINGLE        *
  51. *       PRECISION CALCULATION.                  *
  52. *    4) SPOT CHECKS SHOW ERRORS BOUNDED BY      *
  53. *       4 X 10**-7 BUT FOR ARGUMENTS CLOSE TO   *
  54. *       PI/2 INTERVALS WHERE 10**-5 IS SEEN.    *
  55. *                                               *
  56. *  TIME: (8MHZ NO WAIT STATES AND ARGUMENT      *
  57. *         ASSUMED WITHIN +-PI)                  *
  58. *                                               *
  59. *           FFPSIN       413 MICROSECONDS       *
  60. *           FFPCOS       409 MICROSECONDS       *
  61. *           FFPTAN       501 MICROSECONDS       *
  62. *           FFPSINCS     420 MICROSECONDS       *
  63. *************************************************
  64.          PAGE
  65. FFPSIN   IDNT  1,2 FFP SINE COSINE TANGENT
  66.  
  67.          OPT       PCS
  68.  
  69.          SECTION   9
  70.  
  71.          XDEF      FFPSIN,FFPCOS,FFPTAN,FFPSINCS ENTRY POINTS
  72.  
  73.          XREF      9:FFPTHETA                    INVERSE TANGENT TABLE
  74.  
  75.          XREF      9:FFPMUL,9:FFPDIV,9:FFPSUB    MULTIPLY, DIVIDE AND SUBTRACT
  76.          XREF      9:FFPTNORM          TRANSCENDENTAL NORMALIZE ROUTINE
  77.          XREF      FFPCPYRT            COPYRIGHT STUB
  78.  
  79. PI       EQU       $C90FDB42          FLOATING CONSTANT PI
  80. FIXEDPI  EQU       $C90FDAA2          PI SKELETON TO 32 BITS PRECISION
  81. INV2PI   EQU       $A2F9833E          INVERSE OF TWO-PI
  82. KINV     EQU       $9B74EE40          FLOATING K INVERSE
  83. NKFACT   EQU       $EC916240          NEGATIVE K INVERSE
  84.  
  85. ********************************************
  86. * ENTRY FOR RETURNING BOTH SINE AND COSINE *
  87. ********************************************
  88. FFPSINCS MOVE.W    #-2,-(SP)           FLAG BOTH SINE AND COSINE WANTED
  89.          BRA.S     FPSCOM              ENTER COMMON CODE
  90.  
  91. **********************
  92. * TANGENT ENTRY POINT*
  93. **********************
  94. FFPTAN   MOVE.W    #-1,-(SP)           FLAG TANGENT WITH MINUS VALUE
  95.          BRA.S     FPSCHL              CHECK VERY SMALL VALUES
  96.  
  97. **************************
  98. * COSINE ONLY ENTRY POINT*
  99. **************************
  100. FFPCOS   MOVE.W    #1,-(SP)            FLAG COSINE WITH POSITIVE VALUE
  101.          BRA.S     FPSCOM              ENTER COMMON CODE
  102.  
  103. * NEGATIVE SINE/TANGENT SMALL VALUE CHECK
  104. FPSCHM   CMP.B     #$80+$40-8,D7       ? LESS OR SAME AS -2**-9
  105.          BHI.S     FPSCOM              CONTINUE IF NOT TOO SMALL
  106. * RETURN ARGUMENT
  107. FPSRTI   ADD.L     #2,SP               RID INTERNAL PARAMETER
  108.          TST.B     D7                  SET CONDITION CODES
  109.          RTS                           RETURN TO CALLER
  110.  
  111. ************************
  112. * SINE ONLY ENTRY POINT*
  113. ************************
  114. FFPSIN   CLR.W     -(SP)               FLAG SINE WITH ZERO
  115. * SINE AND TANGENT VALUES < 2**-9 RETURN IDENTITIES
  116. FPSCHL   TST.B     D7                  TEST SIGN
  117.          BMI.S     FPSCHM              BRANCH MINUS
  118.          CMP.B     #$40-8,D7           ? LESS OR SAME THAN 2**-9
  119.          BLS.S     FPSRTI              RETURN IDENTITY
  120.  
  121. * SAVE REGISTERS AND INSURE INPUT WITHIN + OR - PI RANGE
  122. FPSCOM   MOVEM.L   D1-D6/A0,-(SP)      SAVE ALL WORK REGISTERS
  123.          MOVE.L    D7,D2               COPY INPUT OVER
  124.          ADD.B     D7,D7               RID SIGN BIT
  125.          CMP.B     #(64+5)<<1,D7       ? ABS(ARG) < 2**6 (32)
  126.          BLS.S     FPSNLR              BRANCH YES, NOT TOO LARGE
  127. * ARGUMENT IS TOO LARGE TO SUBTRACT TO WITHIN RANGE
  128.          CMP.B     #(64+20)<<1,D7      ? TEST EXCESSIVE SIZE (>2**20)
  129.          BLS.S     FPSGPR              NO, GO AHEAD AND USE
  130. * ERROR - ARGUMENT SO LARGE RESULT HAS NO PRECISION
  131. *        OR.B      #$02,CCR            FORCE V BIT ON
  132.          DC.L      $003C0002           *****ASSEMBLER ERROR*****
  133.          MOVEM.L   (SP)+,D1-D6/A0      RESTORE REGISTERS
  134.          ADD.L     #2,SP               CLEAN INTERNAL ARGUMENT OFF STACK
  135.          RTS                           RETURN TO CALLER
  136.  
  137. * WE MUST FIND MOD(ARG,TWOPI) SINCE ARGUMENT IS TOO LARGE FOR 
  138. SUBTRACTIONS
  139. FPSGPR   MOVE.L    #INV2PI,D6          LOAD UP 2*PI INVERSE CONSTANT
  140.          MOVE.L    D2,D7               COPY OVER INPUT ARGUMENT
  141.          BSR       FFPMUL              DIVIDE BY TWOPI (VIA MULTIPLY INVERSE)
  142. * CONVERT QUOTIENT TO FLOAT INTEGER
  143.          MOVE.B    D7,D5               COPY EXPONENT OVER
  144.          AND.B     #$7F,D5             RID SIGN FROM EXPONENT
  145.          SUB.B     #64+24,D5           FIND FRACTIONAL PRECISION
  146.          NEG.B     D5                  MAKE POSITIVE
  147.          MOVE.L    #-1,D4              SETUP MASK OF ALL ONES
  148.          CLR.B     D4                  START ZEROES AT LOW BYTE
  149.          LSL.L     D5,D4               SHIFT ZEROES INTO FRACTIONAL PART
  150.          OR.B      #$FF,D4             DO NOT REMOVE SIGN AND EXPONENT
  151.          AND.L     D4,D7               STRIP FRACTIONAL BITS ENTIRELY
  152.          MOVE.L    #PI+1,D6            LOAD UP 2*PI CONSTANT
  153.          BSR       FFPMUL              MULTIPLY BACK OUT
  154.          MOVE.L    D7,D6               SETUP TO SUBTRACT MULTIPLE OF TWOPI
  155.          MOVE.L    D2,D7               MOVE ARGUMENT IN
  156.          BSR       FFPSUB              FIND REMAINDER OF TWOPI DIVIDE
  157.          MOVE.L    D7,D2               USE IT AS NEW INPUT ARGUMENT
  158.  
  159. * CONVERT ARGUMENT TO BINARY(31,26) PRECISION FOR REDUCTION WITHIN +-PI
  160. FPSNLR   MOVE.L    #FIXEDPI>>4,D4      LOAD PI
  161.          MOVE.L    D2,D7               COPY FLOAT ARGUMENT
  162.          CLR.B     D7                  CLEAR SIGN AND EXPONENT
  163.          TST.B     D2                  TEST SIGN
  164.          BMI.S     FPSNMI              BRANCH NEGATIVE
  165.          SUB.B     #64+6,D2            OBTAIN SHIFT VALUE
  166.          NEG.B     D2                  FOR 5 BIT NON-FRACTION BITS
  167.          CMP.B     #31,D2              ? VERY SMALL NUMBER
  168.          BLS.S     FPSSH1              NO, GO AHEAD AND SHIFT
  169.          MOVE.L    #0,D7               FORCE TO ZERO
  170. FPSSH1   LSR.L     D2,D7               CONVERT TO FIXED POINT
  171. * FORCE TO +PI OR BELOW
  172. FPSPCK   CMP.L     D4,D7               ? GREATER THAN PI
  173.          BLE.S     FPSCKM              BRANCH NOT
  174.          SUB.L     D4,D7               SUBTRACT
  175.          SUB.L     D4,D7               .  TWOPI
  176.          BRA.S     FPSPCK              AND CHECK AGAIN
  177.  
  178. FPSNMI   SUB.B     #$80+64+6,D2        RID SIGN AND GET SHIFT VALUE
  179.          NEG.B     D2                  FOR 5 NON-FRACTIONAL BITS
  180.          CMP.B     #31,D2              ? VERY SMALL NUMBER
  181.          BLS.S     FPSSH2              NO, GO AHEAD AND SHIFT
  182.          MOVE.L    #0,D7               FORCE TO ZERO
  183. FPSSH2   LSR.L     D2,D7               CONVERT TO FIXED POINT
  184.          NEG.L     D7                  MAKE NEGATIVE
  185.          NEG.L     D4                  MAKE -PI
  186. * FORCE TO -PI OR ABOVE
  187. FPSNCK   CMP.L     D4,D7               ? LESS THAN -PI
  188.          BGE.S     FPSCKM              BRANCH NOT
  189.          SUB.L     D4,D7               ADD
  190.          SUB.L     D4,D7               .  TWOPI
  191.          BRA.S     FPSNCK              AND CHECK AGAIN
  192.  
  193. *****************************************
  194. * CORDIC CALCULATION REGISTERS:         *
  195. * D1 - LOOP COUNT   A0 - TABLE POINTER  *
  196. * D2 - SHIFT COUNT                      *
  197. * D3 - X'   D5 - X                      *
  198. * D4 - Y'   D6 - Y                      *
  199. * D7 - TEST ARGUMENT                    *
  200. *****************************************
  201.  
  202. * INPUT WITHIN RANGE, NOW START CORDIC SETUP
  203. FPSCKM   MOVE.L    #0,D5               X=0
  204.          MOVE.L    #NKFACT,D6          Y=NEGATIVE INVERSE K FACTOR SEED
  205.          MOVE.L    #FIXEDPI>>2,D4      SETUP FIXED PI/2 CONSTANT
  206.          ASL.L     #3,D7               NOW TO BINARY(31,29) PRECISION
  207.          BMI.S     FPSAP2              BRANCH IF MINUS TO ADD PI/2
  208.          NEG.L     D6                  Y=POSITIVE INVERSE K FACTOR SEED
  209.          NEG.L     D4                  SUBTRACT PI/2 FOR POSITIVE ARGUMENT
  210. FPSAP2   ADD.L     D4,D7               ADD CONSTANT
  211.          LEA       FFPTHETA,A0         LOAD ARCTANGENT TABLE
  212.          MOVE.L    #23,D1              LOOP 24 TIMES
  213.          MOVE.L    #-1,D2              PRIME SHIFT COUNTER
  214. * CORDIC LOOP
  215. FSINLP   ADD.W     #1,D2               INCREMENT SHIFT COUNT
  216.          MOVE.L    D5,D3               COPY X
  217.          MOVE.L    D6,D4               COPY Y
  218.          ASR.L     D2,D3               SHIFT FOR X'
  219.          ASR.L     D2,D4               SHIFT FOR Y'
  220.          TST.L     D7                  TEST ARG VALUE
  221.          BMI.S     FSBMI               BRANCH MINUS TEST
  222.          SUB.L     D4,D5               X=X-Y'
  223.          ADD.L     D3,D6               Y=Y+X'
  224.          SUB.L     (A0)+,D7            ARG=ARG-TABLE(N)
  225.          DBRA      D1,FSINLP           LOOP UNTIL DONE
  226.          BRA.S     FSCOM               ENTER COMMON CODE
  227. FSBMI    ADD.L     D4,D5               X=X+Y'
  228.          SUB.L     D3,D6               Y=Y-X'
  229.          ADD.L     (A0)+,D7            ARG=ARG+TABLE(N)
  230.          DBRA      D1,FSINLP           LOOP UNTIL DONE
  231.  
  232. * NOW SPLIT UP TANGENT AND FFPSINCS FROM SINE AND COSINE
  233. FSCOM    MOVE.W    7*4(SP),D1          RELOAD INTERNAL PARAMETER
  234.          BPL.S     FSSINCOS            BRANCH FOR SINE OR COSINE
  235.  
  236.          ADD.B     #1,D1               SEE IF WAS -1 FOR TANGENT
  237.          BNE.S     FSDUAL              NO, MUST BE BOTH SIN AND COSINE
  238. * TANGENT FINISH
  239.          BSR.S     FSFLOAT             FLOAT Y (SIN)
  240.          MOVE.L    D6,D7               SETUP FOR DIVIDE INTO
  241.          MOVE.L    D5,D6               PREPARE X
  242.          BSR.S     FSFLOAT             FLOAT X (COS)
  243.          BEQ.S     FSTINF              BRANCH INFINITE RESULT
  244.          BSR       FFPDIV              TANGENT = SIN/COS
  245. FSINFRT  MOVEM.L   (SP)+,D1-D6/A0      RESTORE REGISTERS
  246.          ADD.L     #2,SP               DELETE INTERNAL PARAMETER
  247.          RTS                           RETURN TO CALLER
  248. * TANGENT IS INFINITE. RETURN MAXIMUM POSITIVE NUMBER.
  249. FSTINF   MOVE.L    #$FFFFFF7F,D7       LARGEST FFP NUMBER
  250.          BRA.S     FSINFRT             AND CLEAN UP
  251.  
  252. * SINE AND COSINE
  253. FSSINCOS BEQ.S     FSSINE              BRANCH IF SINE
  254.          MOVE.L    D5,D6               USE X FOR COSINE
  255. FSSINE   BSR.S     FSFLOAT             CONVERT TO FLOAT
  256.          MOVE.L    D6,D7               RETURN RESULT
  257.          TST.B     D7                  AND CONDITION CODE TEST
  258.          MOVEM.L   (SP)+,D1-D6/A0      RESTORE REGISTERS
  259.          ADD.L     #2,SP               DELETE INTERNAL PARAMETER
  260.          RTS                           RETURN TO CALLER
  261.  
  262. * BOTH SINE AND COSINE
  263. FSDUAL   MOVE.L    D5,-(SP)            SAVE COSINE DERIVITIVE
  264.          BSR.S     FSFLOAT             CONVERT SINE DERIVITIVE TO FLOAT
  265.          MOVE.L    D6,6*4(SP)          PLACE SINE INTO SAVED D6
  266.          MOVE.L    (SP)+,D6            RESTORE COSINE DERIVITIVE
  267.          BRA.S     FSSINE              AND CONTINUE RESTORING SINE ON THE SLY
  268.  
  269. * FSFLOAT - FLOAT INTERNAL PRECISION BUT TRUNCATE TO ZERO IF < 2**-21
  270. FSFLOAT  MOVE.L    D6,D4               COPY INTERNAL PRECISION VALUE
  271.          BMI.S     FSFNEG              BRANCH NEGATIVE
  272.          CMP.L     #$000000FF,D6       ? TEST MAGNITUDE
  273.          BHI       FFPTNORM            NORMALIZE IF NOT TOO SMALL
  274. FSFZRO   MOVE.L    #0,D6               RETURN A ZERO
  275.          RTS                           RETURN TO CALLER
  276. FSFNEG   ASR.L     #8,D4               SEE IF ALL ONES BITS 8-31
  277.          ADD.L     #1,D4               ? GOES TO ZERO
  278.          BNE       FFPTNORM            NORMALIZE IF NOT TOO SMALL
  279.          BRA.S     FSFZRO              RETURN ZERO
  280.  
  281.  
  282.          END
  283.  
  284.